home *** CD-ROM | disk | FTP | other *** search
/ Micromanía: 150 Juegos 2010 / 150Juegos_16.iso / Shareware / Shape Smash / shape-smash.swf / scripts / mx / containers / utilityClasses / CanvasLayout.as < prev    next >
Encoding:
Text File  |  2010-05-14  |  12.6 KB  |  397 lines
  1. package mx.containers.utilityClasses
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.geom.Rectangle;
  5.    import mx.core.Container;
  6.    import mx.core.EdgeMetrics;
  7.    import mx.core.IUIComponent;
  8.    import mx.core.mx_internal;
  9.    import mx.events.ChildExistenceChangedEvent;
  10.    import mx.events.MoveEvent;
  11.    import mx.styles.IStyleClient;
  12.    
  13.    use namespace mx_internal;
  14.    
  15.    public class CanvasLayout extends Layout
  16.    {
  17.       mx_internal static const VERSION:String = "2.0.1.0";
  18.       
  19.       private static var r:Rectangle = new Rectangle();
  20.       
  21.       private var _contentArea:Rectangle;
  22.       
  23.       public function CanvasLayout()
  24.       {
  25.          super();
  26.       }
  27.       
  28.       private function applyAnchorStylesDuringUpdateDisplayList(param1:Number, param2:Number, param3:IUIComponent) : void
  29.       {
  30.          var _loc4_:IStyleClient = null;
  31.          var _loc5_:Number = NaN;
  32.          var _loc6_:Number = NaN;
  33.          var _loc7_:Number = NaN;
  34.          var _loc8_:Number = NaN;
  35.          var _loc9_:Number = NaN;
  36.          var _loc10_:Number = NaN;
  37.          var _loc11_:Number = NaN;
  38.          var _loc12_:Number = NaN;
  39.          var _loc13_:Number = NaN;
  40.          var _loc14_:Number = NaN;
  41.          var _loc15_:Boolean = false;
  42.          var _loc16_:Boolean = false;
  43.          _loc4_ = param3 as IStyleClient;
  44.          if(!_loc4_)
  45.          {
  46.             return;
  47.          }
  48.          _loc5_ = _loc4_.getStyle("left");
  49.          _loc6_ = _loc4_.getStyle("right");
  50.          _loc7_ = _loc4_.getStyle("horizontalCenter");
  51.          _loc8_ = _loc4_.getStyle("top");
  52.          _loc9_ = _loc4_.getStyle("bottom");
  53.          _loc10_ = _loc4_.getStyle("verticalCenter");
  54.          _loc15_ = false;
  55.          _loc16_ = false;
  56.          if(!isNaN(_loc5_) && !isNaN(_loc6_))
  57.          {
  58.             _loc11_ = param1 - _loc5_ - _loc6_;
  59.             if(_loc11_ < param3.minWidth)
  60.             {
  61.                _loc11_ = param3.minWidth;
  62.             }
  63.          }
  64.          else if(!isNaN(param3.percentWidth))
  65.          {
  66.             _loc11_ = param3.percentWidth / 100 * param1;
  67.             _loc11_ = bound(_loc11_,param3.minWidth,param3.maxWidth);
  68.             _loc15_ = true;
  69.          }
  70.          else
  71.          {
  72.             _loc11_ = param3.getExplicitOrMeasuredWidth();
  73.          }
  74.          if(!isNaN(_loc8_) && !isNaN(_loc9_))
  75.          {
  76.             _loc12_ = param2 - _loc8_ - _loc9_;
  77.             if(_loc12_ < param3.minHeight)
  78.             {
  79.                _loc12_ = param3.minHeight;
  80.             }
  81.          }
  82.          else if(!isNaN(param3.percentHeight))
  83.          {
  84.             _loc12_ = param3.percentHeight / 100 * param2;
  85.             _loc12_ = bound(_loc12_,param3.minHeight,param3.maxHeight);
  86.             _loc16_ = true;
  87.          }
  88.          else
  89.          {
  90.             _loc12_ = param3.getExplicitOrMeasuredHeight();
  91.          }
  92.          if(!isNaN(_loc7_))
  93.          {
  94.             _loc13_ = Math.round((param1 - _loc11_) / 2 + _loc7_);
  95.          }
  96.          else if(!isNaN(_loc5_))
  97.          {
  98.             _loc13_ = _loc5_;
  99.          }
  100.          else if(!isNaN(_loc6_))
  101.          {
  102.             _loc13_ = param1 - _loc6_ - _loc11_;
  103.          }
  104.          if(!isNaN(_loc10_))
  105.          {
  106.             _loc14_ = Math.round((param2 - _loc12_) / 2 + _loc10_);
  107.          }
  108.          else if(!isNaN(_loc8_))
  109.          {
  110.             _loc14_ = _loc8_;
  111.          }
  112.          else if(!isNaN(_loc9_))
  113.          {
  114.             _loc14_ = param2 - _loc9_ - _loc12_;
  115.          }
  116.          _loc13_ = isNaN(_loc13_) ? Number(param3.x) : _loc13_;
  117.          _loc14_ = isNaN(_loc14_) ? Number(param3.y) : _loc14_;
  118.          param3.move(_loc13_,_loc14_);
  119.          if(_loc15_)
  120.          {
  121.             if(_loc13_ + _loc11_ > param1)
  122.             {
  123.                _loc11_ = Math.max(param1 - _loc13_,param3.minWidth);
  124.             }
  125.          }
  126.          if(_loc16_)
  127.          {
  128.             if(_loc14_ + _loc12_ > param2)
  129.             {
  130.                _loc12_ = Math.max(param2 - _loc14_,param3.minHeight);
  131.             }
  132.          }
  133.          if(!isNaN(_loc11_) && !isNaN(_loc12_))
  134.          {
  135.             param3.setActualSize(_loc11_,_loc12_);
  136.          }
  137.       }
  138.       
  139.       override public function set target(param1:Container) : void
  140.       {
  141.          var _loc2_:Container = null;
  142.          var _loc3_:int = 0;
  143.          var _loc4_:int = 0;
  144.          _loc2_ = super.target;
  145.          if(param1 != _loc2_)
  146.          {
  147.             if(_loc2_)
  148.             {
  149.                _loc2_.removeEventListener(ChildExistenceChangedEvent.CHILD_ADD,target_childAddHandler);
  150.                _loc2_.removeEventListener(ChildExistenceChangedEvent.CHILD_REMOVE,target_childRemoveHandler);
  151.                _loc4_ = _loc2_.numChildren;
  152.                _loc3_ = 0;
  153.                while(_loc3_ < _loc4_)
  154.                {
  155.                   DisplayObject(_loc2_.getChildAt(_loc3_)).removeEventListener(MoveEvent.MOVE,child_moveHandler);
  156.                   _loc3_++;
  157.                }
  158.             }
  159.             if(param1)
  160.             {
  161.                param1.addEventListener(ChildExistenceChangedEvent.CHILD_ADD,target_childAddHandler);
  162.                param1.addEventListener(ChildExistenceChangedEvent.CHILD_REMOVE,target_childRemoveHandler);
  163.                _loc4_ = param1.numChildren;
  164.                _loc3_ = 0;
  165.                while(_loc3_ < _loc4_)
  166.                {
  167.                   DisplayObject(param1.getChildAt(_loc3_)).addEventListener(MoveEvent.MOVE,child_moveHandler);
  168.                   _loc3_++;
  169.                }
  170.             }
  171.             super.target = param1;
  172.          }
  173.       }
  174.       
  175.       override public function measure() : void
  176.       {
  177.          var _loc1_:Container = null;
  178.          var _loc2_:Number = NaN;
  179.          var _loc3_:Number = NaN;
  180.          var _loc4_:EdgeMetrics = null;
  181.          var _loc5_:Rectangle = null;
  182.          _loc1_ = super.target;
  183.          _loc2_ = 0;
  184.          _loc3_ = 0;
  185.          _loc4_ = _loc1_.viewMetrics;
  186.          _contentArea = null;
  187.          _loc5_ = measureContentArea();
  188.          _loc1_.measuredWidth = _loc5_.width + _loc4_.left + _loc4_.right;
  189.          _loc1_.measuredHeight = _loc5_.height + _loc4_.top + _loc4_.bottom;
  190.       }
  191.       
  192.       private function target_childAddHandler(param1:ChildExistenceChangedEvent) : void
  193.       {
  194.          DisplayObject(param1.relatedObject).addEventListener(MoveEvent.MOVE,child_moveHandler);
  195.       }
  196.       
  197.       private function measureContentArea() : Rectangle
  198.       {
  199.          var _loc1_:int = 0;
  200.          var _loc2_:int = 0;
  201.          var _loc3_:IUIComponent = null;
  202.          var _loc4_:IStyleClient = null;
  203.          var _loc5_:Number = NaN;
  204.          var _loc6_:Number = NaN;
  205.          var _loc7_:Number = NaN;
  206.          var _loc8_:Number = NaN;
  207.          var _loc9_:Number = NaN;
  208.          var _loc10_:Number = NaN;
  209.          if(_contentArea)
  210.          {
  211.             return _contentArea;
  212.          }
  213.          _contentArea = new Rectangle();
  214.          _loc1_ = target.numChildren;
  215.          _loc2_ = 0;
  216.          while(_loc2_ < _loc1_)
  217.          {
  218.             _loc3_ = target.getChildAt(_loc2_) as IUIComponent;
  219.             _loc4_ = _loc3_ as IStyleClient;
  220.             if(_loc3_.includeInLayout)
  221.             {
  222.                _loc5_ = Number(_loc3_.x);
  223.                _loc6_ = Number(_loc3_.y);
  224.                _loc7_ = _loc3_.getExplicitOrMeasuredWidth();
  225.                _loc8_ = _loc3_.getExplicitOrMeasuredHeight();
  226.                if(!isNaN(_loc3_.percentWidth) || _loc4_ && !isNaN(_loc4_.getStyle("left")) && !isNaN(_loc4_.getStyle("right")))
  227.                {
  228.                   _loc7_ = _loc3_.minWidth;
  229.                }
  230.                if(!isNaN(_loc3_.percentHeight) || _loc4_ && !isNaN(_loc4_.getStyle("top")) && !isNaN(_loc4_.getStyle("bottom")))
  231.                {
  232.                   _loc8_ = _loc3_.minHeight;
  233.                }
  234.                r.x = _loc5_;
  235.                r.y = _loc6_;
  236.                r.width = _loc7_;
  237.                r.height = _loc8_;
  238.                applyAnchorStylesDuringMeasure(_loc3_,r);
  239.                _loc5_ = r.x;
  240.                _loc6_ = r.y;
  241.                _loc7_ = r.width;
  242.                _loc8_ = r.height;
  243.                if(isNaN(_loc5_))
  244.                {
  245.                   _loc5_ = Number(_loc3_.x);
  246.                }
  247.                if(isNaN(_loc6_))
  248.                {
  249.                   _loc6_ = Number(_loc3_.y);
  250.                }
  251.                _loc9_ = _loc5_;
  252.                _loc10_ = _loc6_;
  253.                if(isNaN(_loc7_))
  254.                {
  255.                   _loc7_ = Number(_loc3_.width);
  256.                }
  257.                if(isNaN(_loc8_))
  258.                {
  259.                   _loc8_ = Number(_loc3_.height);
  260.                }
  261.                _loc9_ += _loc7_;
  262.                _loc10_ += _loc8_;
  263.                _contentArea.right = Math.max(_contentArea.right,_loc9_);
  264.                _contentArea.bottom = Math.max(_contentArea.bottom,_loc10_);
  265.             }
  266.             _loc2_++;
  267.          }
  268.          return _contentArea;
  269.       }
  270.       
  271.       private function child_moveHandler(param1:MoveEvent) : void
  272.       {
  273.          var _loc2_:Container = null;
  274.          if(param1.target is IUIComponent)
  275.          {
  276.             if(!IUIComponent(param1.target).includeInLayout)
  277.             {
  278.                return;
  279.             }
  280.          }
  281.          _loc2_ = super.target;
  282.          if(_loc2_)
  283.          {
  284.             _loc2_.invalidateSize();
  285.             _loc2_.invalidateDisplayList();
  286.             _contentArea = null;
  287.          }
  288.       }
  289.       
  290.       override public function updateDisplayList(param1:Number, param2:Number) : void
  291.       {
  292.          var _loc3_:Container = null;
  293.          var _loc4_:EdgeMetrics = null;
  294.          var _loc5_:Number = NaN;
  295.          var _loc6_:Number = NaN;
  296.          var _loc7_:int = 0;
  297.          var _loc8_:int = 0;
  298.          var _loc9_:IUIComponent = null;
  299.          _loc3_ = super.target;
  300.          _loc3_.mx_internal::doingLayout = false;
  301.          _loc4_ = _loc3_.viewMetrics;
  302.          _loc3_.mx_internal::doingLayout = true;
  303.          _loc5_ = param1 - _loc4_.left - _loc4_.right;
  304.          _loc6_ = param2 - _loc4_.top - _loc4_.bottom;
  305.          _loc7_ = _loc3_.numChildren;
  306.          _loc8_ = 0;
  307.          while(_loc8_ < _loc7_)
  308.          {
  309.             _loc9_ = _loc3_.getChildAt(_loc8_) as IUIComponent;
  310.             applyAnchorStylesDuringUpdateDisplayList(_loc5_,_loc6_,_loc9_);
  311.             _loc8_++;
  312.          }
  313.       }
  314.       
  315.       private function applyAnchorStylesDuringMeasure(param1:IUIComponent, param2:Rectangle) : void
  316.       {
  317.          var _loc3_:IStyleClient = null;
  318.          var _loc4_:Number = NaN;
  319.          var _loc5_:Number = NaN;
  320.          var _loc6_:Number = NaN;
  321.          var _loc7_:Number = NaN;
  322.          var _loc8_:Number = NaN;
  323.          var _loc9_:Number = NaN;
  324.          _loc3_ = param1 as IStyleClient;
  325.          if(!_loc3_)
  326.          {
  327.             return;
  328.          }
  329.          _loc4_ = _loc3_.getStyle("left");
  330.          _loc5_ = _loc3_.getStyle("right");
  331.          _loc6_ = _loc3_.getStyle("horizontalCenter");
  332.          if(!isNaN(_loc6_))
  333.          {
  334.             param2.x = Math.round((target.width - param1.width) / 2 + _loc6_);
  335.          }
  336.          else if(!isNaN(_loc4_) && !isNaN(_loc5_))
  337.          {
  338.             param2.x = _loc4_;
  339.             param2.width += _loc5_;
  340.          }
  341.          else if(!isNaN(_loc4_))
  342.          {
  343.             param2.x = _loc4_;
  344.          }
  345.          else if(!isNaN(_loc5_))
  346.          {
  347.             param2.x = 0;
  348.             param2.width += _loc5_;
  349.          }
  350.          _loc7_ = _loc3_.getStyle("top");
  351.          _loc8_ = _loc3_.getStyle("bottom");
  352.          _loc9_ = _loc3_.getStyle("verticalCenter");
  353.          if(!isNaN(_loc9_))
  354.          {
  355.             param2.y = Math.round((target.height - param1.height) / 2 + _loc9_);
  356.          }
  357.          else if(!isNaN(_loc7_) && !isNaN(_loc8_))
  358.          {
  359.             param2.y = _loc7_;
  360.             param2.height += _loc8_;
  361.          }
  362.          else if(!isNaN(_loc7_))
  363.          {
  364.             param2.y = _loc7_;
  365.          }
  366.          else if(!isNaN(_loc8_))
  367.          {
  368.             param2.y = 0;
  369.             param2.height += _loc8_;
  370.          }
  371.       }
  372.       
  373.       private function bound(param1:Number, param2:Number, param3:Number) : Number
  374.       {
  375.          if(param1 < param2)
  376.          {
  377.             param1 = param2;
  378.          }
  379.          else if(param1 > param3)
  380.          {
  381.             param1 = param3;
  382.          }
  383.          else
  384.          {
  385.             param1 = Math.floor(param1);
  386.          }
  387.          return param1;
  388.       }
  389.       
  390.       private function target_childRemoveHandler(param1:ChildExistenceChangedEvent) : void
  391.       {
  392.          DisplayObject(param1.relatedObject).removeEventListener(MoveEvent.MOVE,child_moveHandler);
  393.       }
  394.    }
  395. }
  396.  
  397.